package com.jfplugin.mail.core;

import com.jfplugin.mail.exception.*;

import javax.activation.FileTypeMap;
import javax.mail.*;
import javax.mail.internet.MimeMessage;
import java.io.InputStream;
import java.util.*;

/**
 * @author farmer
 */
public class JavaMailSenderImpl implements JavaMailSender {

    /**
     * The default protocol: 'smtp'
     */
    public static final String DEFAULT_PROTOCOL = "smtp";

    /**
     * The default port: -1
     */
    public static final int DEFAULT_PORT = -1;

    private static final String HEADER_MESSAGE_ID = "Message-ID";

    private Properties javaMailProperties = new Properties();

    private Session session;

    private String protocol = DEFAULT_PROTOCOL;

    private String host;

    private int port = DEFAULT_PORT;

    private String username;

    private String password;

    private String defaultEncoding;

    private FileTypeMap defaultFileTypeMap;

    /**
     * Create a new instance of the <code>JavaMailSenderImpl</code> class.
     * <p>Initializes the {@link #setDefaultFileTypeMap "defaultFileTypeMap"}
     * property with a default {@link ConfigurableMimeFileTypeMap}.
     */
    public JavaMailSenderImpl() {
        ConfigurableMimeFileTypeMap fileTypeMap = new ConfigurableMimeFileTypeMap();
        fileTypeMap.afterPropertiesSet();
        this.defaultFileTypeMap = fileTypeMap;
    }

    /**
     * Allow Map access to the JavaMail properties of this sender,
     * with the option to add or override specific entries.
     * <p>Useful for specifying entries directly, for example via
     * "javaMailProperties[mail.smtp.auth]".
     *
     * @return Properties
     */
    public Properties getJavaMailProperties() {
        return this.javaMailProperties;
    }

    /**
     * Set JavaMail properties for the <code>Session</code>.
     * <p>A new <code>Session</code> will be created with those properties.
     * Use either this method or {@link #setSession}, but not both.
     * <p>Non-default properties in this instance will override given
     *
     * @param javaMailProperties JavaMail properties.
     */
    public void setJavaMailProperties(Properties javaMailProperties) {
        this.javaMailProperties = javaMailProperties;
        synchronized (this) {
            this.session = null;
        }
    }

    /**
     * Return the JavaMail <code>Session</code>,
     * lazily initializing it if hasn't been specified explicitly.
     *
     * @return Session
     */
    public synchronized Session getSession() {
        if (this.session == null) {
            this.session = Session.getInstance(this.javaMailProperties);
        }
        return this.session;
    }

    /**
     * Set the JavaMail <code>Session</code>, possibly pulled from JNDI.
     * <p>Default is a new <code>Session</code> without defaults, that is
     * completely configured via this instance's properties.
     * <p>If using a pre-configured <code>Session</code>, non-default properties
     * in this instance will override the settings in the <code>Session</code>.
     *
     * @param session
     * @see #setJavaMailProperties
     */
    public synchronized void setSession(Session session) {
        Assert.notNull(session, "Session must not be null");
        this.session = session;
    }

    /**
     * @return the mail protocol.
     */
    public String getProtocol() {
        return this.protocol;
    }

    /**
     * Set the mail protocol. Default is "smtp".
     *
     * @param protocol protocol
     */
    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }

    /**
     * @return the mail server host.
     */
    public String getHost() {
        return this.host;
    }

    /**
     * Set the mail server host, typically an SMTP host.
     * <p>Default is the default host of the underlying JavaMail Session.
     *
     * @param host host
     */
    public void setHost(String host) {
        this.host = host;
    }

    /**
     * @return the mail server port.
     */
    public int getPort() {
        return this.port;
    }

    /**
     * Set the mail server port.
     * <p>Default is {@link #DEFAULT_PORT}, letting JavaMail use the default
     * SMTP port (25).
     *
     * @param port
     */
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * @return the username for the account at the mail host.
     */
    public String getUsername() {
        return this.username;
    }

    /**
     * Set the username for the account at the mail host, if any.
     * <p>Note that the underlying JavaMail <code>Session</code> has to be
     * configured with the property <code>"mail.smtp.auth"</code> set to
     * <code>true</code>, else the specified username will not be sent to the
     * mail server by the JavaMail runtime. If you are not explicitly passing
     * in a <code>Session</code> to use, simply specify this setting via
     * {@link #setJavaMailProperties}.
     *
     * @param username username
     * @see #setSession
     * @see #setPassword
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * @return the password for the account at the mail host.
     */
    public String getPassword() {
        return this.password;
    }

    /**
     * Set the password for the account at the mail host, if any.
     * <p>Note that the underlying JavaMail <code>Session</code> has to be
     * configured with the property <code>"mail.smtp.auth"</code> set to
     * <code>true</code>, else the specified password will not be sent to the
     * mail server by the JavaMail runtime. If you are not explicitly passing
     * in a <code>Session</code> to use, simply specify this setting via
     * {@link #setJavaMailProperties}.
     *
     * @param password password
     * @see #setSession
     * @see #setUsername
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * @return the default encoding for {@link MimeMessage MimeMessages},
     * or <code>null</code> if none.
     */
    public String getDefaultEncoding() {
        return this.defaultEncoding;
    }

    /**
     * Set the default encoding to use for {@link MimeMessage MimeMessages}
     * created by this instance.
     * <p>Such an encoding will be auto-detected by {@link MimeMessageHelper}.
     *
     * @param defaultEncoding defaultEncoding
     */
    public void setDefaultEncoding(String defaultEncoding) {
        this.defaultEncoding = defaultEncoding;
    }

    /**
     * @return the default Java Activation {@link FileTypeMap} for
     * {@link MimeMessage MimeMessages}, or <code>null</code> if none.
     */
    public FileTypeMap getDefaultFileTypeMap() {
        return this.defaultFileTypeMap;
    }

    /**
     * Set the default Java Activation {@link FileTypeMap} to use for
     * {@link MimeMessage MimeMessages} created by this instance.
     * <p>A <code>FileTypeMap</code> specified here will be autodetected by
     * {@link MimeMessageHelper}, avoiding the need to specify the
     * <code>FileTypeMap</code> for each <code>MimeMessageHelper</code> instance.
     * <p>For example, you can specify a custom instance of Spring's
     * {@link ConfigurableMimeFileTypeMap} here. If not explicitly specified,
     * a default <code>ConfigurableMimeFileTypeMap</code> will be used, containing
     * an extended set of MIME type mappings (as defined by the
     * <code>mime.types</code> file contained in the Spring jar).
     *
     * @param defaultFileTypeMap defaultFileTypeMap
     * @see MimeMessageHelper#setFileTypeMap
     */
    public void setDefaultFileTypeMap(FileTypeMap defaultFileTypeMap) {
        this.defaultFileTypeMap = defaultFileTypeMap;
    }


    //---------------------------------------------------------------------
    // Implementation of MailSender
    //---------------------------------------------------------------------

    @Override
    public void send(SimpleMailMessage simpleMessage) throws BaseMailException {
        send(new SimpleMailMessage[]{simpleMessage});
    }

    @Override
    public void send(SimpleMailMessage[] simpleMessages) throws BaseMailException {
        List<MimeMessage> mimeMessages = new ArrayList<>(simpleMessages.length);
        for (SimpleMailMessage simpleMessage : simpleMessages) {
            MimeMailMessage message = new MimeMailMessage(createMimeMessage());
            simpleMessage.copyTo(message);
            mimeMessages.add(message.getMimeMessage());
        }
        doSend(mimeMessages.toArray(new MimeMessage[0]), simpleMessages);
    }


    //---------------------------------------------------------------------
    // Implementation of JavaMailSender
    //---------------------------------------------------------------------

    /**
     * This implementation creates a SmartMimeMessage, holding the specified
     * default encoding and default FileTypeMap. This special defaults-carrying
     * message will be autodetected by {@link MimeMessageHelper}, which will use
     * the carried encoding and FileTypeMap unless explicitly overridden.
     *
     * @see #setDefaultEncoding
     * @see #setDefaultFileTypeMap
     */
    @Override
    public MimeMessage createMimeMessage() {
        return new SmartMimeMessage(getSession(), getDefaultEncoding(), getDefaultFileTypeMap());
    }

    @Override
    public MimeMessage createMimeMessage(InputStream contentStream) throws BaseMailException {
        try {
            return new MimeMessage(getSession(), contentStream);
        } catch (MessagingException ex) {
            throw new MailParseException("Could not parse raw MIME content", ex);
        }
    }

    @Override
    public void send(MimeMessage mimeMessage) throws BaseMailException {
        send(new MimeMessage[]{mimeMessage});
    }

    @Override
    public void send(MimeMessage[] mimeMessages) throws BaseMailException {
        doSend(mimeMessages, null);
    }

    @Override
    public void send(MimeMessagePreparator mimeMessagePreparator) throws BaseMailException {
        send(new MimeMessagePreparator[]{mimeMessagePreparator});
    }

    @Override
    public void send(MimeMessagePreparator[] mimeMessagePreparators) throws BaseMailException {
        try {
            List<MimeMessage> mimeMessages = new ArrayList<>(mimeMessagePreparators.length);
            for (MimeMessagePreparator preparator : mimeMessagePreparators) {
                MimeMessage mimeMessage = createMimeMessage();
                preparator.prepare(mimeMessage);
                mimeMessages.add(mimeMessage);
            }
            send(mimeMessages.toArray(new MimeMessage[0]));
        } catch (BaseMailException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new MailPreparationException(ex);
        }
    }

    /**
     * Actually send the given array of MimeMessages via JavaMail.
     *
     * @param mimeMessages     MimeMessage objects to send
     * @param originalMessages corresponding original message objects
     *                         that the MimeMessages have been created from (with same array
     *                         length and indices as the "mimeMessages" array), if any
     */
    protected void doSend(MimeMessage[] mimeMessages, Object[] originalMessages) throws BaseMailException {
        Map<Object, Exception> failedMessages = new LinkedHashMap<>();

        Transport transport;
        try {
            transport = getTransport(getSession());
            transport.connect(getHost(), getPort(), getUsername(), getPassword());
        } catch (AuthenticationFailedException ex) {
            throw new MailAuthenticationException(ex);
        } catch (MessagingException ex) {
            // Effectively, all messages failed...
            for (int i = 0; i < mimeMessages.length; i++) {
                Object original = (originalMessages != null ? originalMessages[i] : mimeMessages[i]);
                failedMessages.put(original, ex);
            }
            throw new MailSendException("Mail server connection failed", ex, failedMessages);
        }

        try {
            for (int i = 0; i < mimeMessages.length; i++) {
                MimeMessage mimeMessage = mimeMessages[i];
                try {
                    if (mimeMessage.getSentDate() == null) {
                        mimeMessage.setSentDate(new Date());
                    }
                    String messageId = mimeMessage.getMessageID();
                    mimeMessage.saveChanges();
                    if (messageId != null) {
                        // Preserve explicitly specified message id...
                        mimeMessage.setHeader(HEADER_MESSAGE_ID, messageId);
                    }
                    transport.sendMessage(mimeMessage, mimeMessage.getAllRecipients());
                } catch (MessagingException ex) {
                    failedMessages.put((originalMessages == null ? mimeMessage : originalMessages[i]), ex);
                }
            }
        } finally {
            try {
                transport.close();
            } catch (MessagingException ex) {
                if (!failedMessages.isEmpty()) {
                    throw new MailSendException("Failed to close server connection after message failures", ex, failedMessages);
                } else {
                    throw new MailSendException("Failed to close server connection after message sending", ex);
                }
            }
        }

        if (!failedMessages.isEmpty()) {
            throw new MailSendException(failedMessages);
        }
    }

    /**
     * Obtain a Transport object from the given JavaMail Session,
     * using the configured protocol.
     * <p>Can be overridden in subclasses, e.g. to return a mock Transport object.
     *
     * @see javax.mail.Session#getTransport(String)
     * @see #getProtocol()
     */
    protected Transport getTransport(Session session) throws NoSuchProviderException {
        return session.getTransport(getProtocol());
    }


}
